home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1998 July / EnigmA AMIGA RUN 29 (1998)(G.R. Edizioni)(IT)[!][issue 1998-07 & 08].iso / earcd / grafica / ghostscript / 5.10 / data / writecff.ps < prev    next >
Text File  |  1997-09-19  |  11KB  |  367 lines
  1. %    Copyright (C) 1997 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of Aladdin Ghostscript.
  4. % 
  5. % Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6. % or distributor accepts any responsibility for the consequences of using it,
  7. % or for whether it serves any particular purpose or works at all, unless he
  8. % or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9. % License (the "License") for full details.
  10. % 
  11. % Every copy of Aladdin Ghostscript must include a copy of the License,
  12. % normally in a plain ASCII text file named PUBLIC.  The License grants you
  13. % the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14. % under certain conditions described in the License.  Among other things, the
  15. % License requires that the copyright notice and this notice be preserved on
  16. % all copies.
  17.  
  18. % writecff.ps
  19. % Write out a Type 2 font as CFF.
  20. % **************** THIS FILE DOES NOT WORK. ****************
  21. % **************** DON'T TRY TO USE IT. ****************
  22.  
  23. currentglobal true setglobal
  24. (gs_cff.ps) runlibfile
  25. setglobal
  26.  
  27. 50 dict begin
  28.  
  29. % ---------------- Standard strings/names ---------------- %
  30.  
  31. /FontSetInit /ProcSet findresource begin mark
  32.  
  33. /StandardSIDs StandardStrings length 1.5 mul cvi dict
  34. dup 0 1 StandardStrings length 1 sub {
  35.         % Stack: mark /StdSIDs dict dict index
  36.   dup StandardStrings exch get exch put dup
  37. } for pop
  38.  
  39. end counttomark 2 idiv { def } repeat pop
  40.  
  41. % ---------------- Standard encodings ---------------- %
  42.  
  43. % ---------------- Standard Charsets ---------------- %
  44.  
  45. % ---------------- Output utilities ---------------- %
  46.  
  47. % Free variables: f (output file), fpos (position in f).
  48.  
  49. /advance {        % <n> advance -
  50.   fpos add /fpos exch store
  51. } def
  52. /next {            % <byte> next -
  53.   f exch write 1 advance
  54. } def
  55. /nextstring {        % <string|name> nextstring -
  56.   dup type /nametype eq { .namestring } if
  57.   f 1 index writestring length advance
  58. } def
  59. /card8            % <card8> card8 -
  60.   /next load
  61. def
  62. /card16 {        % <card16> card16 -
  63.   dup -8 bitshift next 255 and next
  64. } def
  65. /offset {        % <offset> <offsize> offset -
  66.   1 sub -1 0 { -8 mul 2 copy bitshift 255 and next pop } for pop
  67. } def
  68. /sid            % <sid> sid -
  69.   /card16 load
  70. def
  71. /lenoffsize {        % <length> lenoffsize <offsize>
  72.   dup 255 le { pop 1 } { -8 bitshift lenoffsize 1 add } ifelse
  73. } def
  74. /Index {        % [<string|name|null> ...] Index -
  75.     % Calculate the maximum offset we need to be able to represent.
  76.   1 1 index { dup null eq { pop } { length add } ifelse } forall lenoffsize
  77.     % stack: items offsize
  78.   1 index length card16
  79.   dup next
  80.   1 2 index {
  81.       % stack: items offsize pos item
  82.     1 index 3 index offset
  83.     dup null eq { pop } { length add } ifelse
  84.   } forall exch offset { nextstring } forall
  85. } def
  86. /idIndex {        % <dict> <base> idIndex -
  87.   1 index length array 3 -1 roll {
  88.     3 index sub 2 index exch 3 -1 roll put
  89.   } forall exch pop Index
  90. } def
  91. /stringid {        % <string|name> stringid <sid>
  92.   StandardSIDs 1 index .knownget {
  93.     exch pop
  94.   } {
  95.     sids 1 index .knownget {
  96.       exch pop
  97.     } {
  98.       StandardSIDs length sids length add sids 3 -1 roll 2 index put
  99.     } ifelse
  100.   } ifelse
  101. } def
  102. /.valuetypedict mark
  103.   /booleantype { { 1 } { 0 } ifelse intvalue }
  104.   /arraytype { { value } forall }
  105.   /packedarraytype 1 index
  106.   /stringtype { stringid intvalue }
  107.   /nametype 1 index
  108.   /realtype { realvalue }
  109.   /integertype { intvalue }
  110. .dicttomark readonly def
  111. /value {        % <obj> value -
  112.   dup type .valuetypedict exch get exec
  113. } def
  114. /.realchardict mark
  115.   48 1 57 { dup 48 sub } for    % digits
  116.   46 10   69 11   101 11    % . E e
  117.   45 {                % - -- handle E- specially
  118.     dup 15 and 11 eq { 15 or 12 } {
  119.       dup 16#bf eq { pop 255 12 } { 14 } ifelse
  120.     } ifelse
  121.   }
  122. .dicttomark readonly def
  123. /realvalue {        % <real> realvalue -
  124.   =string cvs 255 exch {
  125.     .realchardict exch get exec
  126.     1 index 15 and 15 ne { exch next 255 exch } if
  127.     1 index 240 and 240 eq { 4 bitshift 240 } { 15 } ifelse sub add
  128.   } forall next
  129. } def
  130. /intvalue {        % <int> intvalue -
  131.   dup dup -107 ge exch 107 le and { 139 add next } {
  132.     dup dup -1131 ge exch 0 lt and { neg 16#fa94 add card16 } {
  133.       dup dup 1131 le exch 0 ge and { 16#f694 add card16 } {
  134.     dup dup -32768 ge exch 32767 le and {
  135.       28 next 65535 and card16
  136.     } {
  137.       29 next dup -16 bitshift 2 { 65535 and card16 } repeat
  138.     } ifelse
  139.       } ifelse
  140.     } ifelse
  141.   } ifelse
  142. } def
  143. /op {            % <op> op -
  144.   dup 32 ge { 12 next 32 sub } if next
  145. } def
  146. /vdef {            % <obj> <op> vdef -
  147.   exch value op
  148. } def
  149. /nedef {        % <obj> <default> <op> nedef -
  150.   exch 2 index eq { pop pop } { vdef } ifelse
  151. } def
  152. /Dict {            % <dict> <opsdict> Dict -
  153.   exch {
  154.     % stack: opsdict key value
  155.     2 index 3 -1 roll .knownget {
  156.       dup type /integertype eq { vdef } { exec } ifelse
  157.     } {
  158.       pop
  159.     } ifelse
  160.   } forall pop
  161. } def
  162. /collect {        % <proc> collect <string>
  163.   10 dict begin
  164.   /str 500 string def
  165.   /spos 0 def
  166.   /fpos 0 def
  167.   /f {
  168.     pop length spos add /spos exch store
  169.     spos str length eq { /str str str concatstrings def } if
  170.     str spos str length spos sub getinterval
  171.   } /NullEncode filter def
  172.   exec f closefile
  173.   str 0 spos getinterval end
  174. } def
  175.  
  176. % Write a forward reference in a Dict, and save its position.
  177. /forward {        % <varname> <op> <offsize> forward -
  178.   {null null <1c 00 00> <1d 00 00 00 00>} exch get nextstring
  179.   exch fpos store op
  180. } def
  181.  
  182. % ------ Top (font) dictionary ------ %
  183.  
  184. /topkeyops mark
  185.   /version 0
  186.   /Notice 1
  187.   /Copyright 32
  188.   /FullName 2
  189.   /FamilyName 3
  190.   /Weight 4
  191.   /isFixedPatch { false 33 nedef }
  192.   /ItalicAngle { 0 34 nedef }
  193.   /UnderlinePosition { -100 35 nedef }
  194.   /UnderlineThickness { 50 36 nedef }
  195.   /PaintType { 0 37 nedef }
  196.   /CharstringType { 2 38 nedef }
  197.   /FontMatrix {
  198.     true 0 1 5 {
  199.       2 index 1 index get {0.001 0 0 0.001 0 0} 3 -1 roll get eq and
  200.     } for
  201.     { pop } { 39 vdef } ifelse
  202.   }
  203.   /UniqueID 13
  204.   /FontBBox 5
  205.   /StrokeWidth { 0 40 nedef }
  206.   /XUID 14
  207.   /FontInfo { topkeyops Dict }
  208.     %**** charset, Encoding
  209.   /CharStrings { pop /charstringsoffset 17 offsetsize forward }
  210.   /Private { pop /privateoffset 18 offsetsize forward }
  211. .dicttomark readonly def
  212.  
  213. % ------ Private dictionary ------ %
  214.  
  215. /deltarray {        % [<num> ...] <op> deltarray -
  216.   exch 0 exch { 1 index sub dup value add } forall pop op
  217. } def
  218. /privatekeyops mark
  219.   /BlueValues { 6 deltarray }
  220.   /OtherBlues { 7 deltarray }
  221.   /FamilyBlues { 8 deltarray }
  222.   /FamilyOtherBlues { 9 deltarray }
  223.   /BlueScale { 0.039625 41 nedef }
  224.   /BlueShift { 7 42 nedef }
  225.   /BlueFuzz { 1 43 nedef }
  226.   /StdHW 10
  227.   /StdVW 11
  228.   /StemSnapH { 44 deltarray }
  229.   /StemSnapV { 45 deltarray }
  230.   /ForceBold { false 46 nedef }
  231.   /ForceBoldThreshold { 0 47 nedef }
  232.     % Skip lenIV, it's always -1
  233.   /LanguageGroup { 0 49 nedef }
  234.   /ExpansionFactor { 0.06 50 nedef }
  235.   /initialRandomSeed { 0 51 nedef }
  236.   /Subrs { pop /subrsoffset 19 2 forward }
  237.   /defaultWidthX { 0 20 nedef }
  238.   /nominalWidthX { 0 21 nedef }
  239. .dicttomark readonly def
  240.  
  241. % ------ Main program ------ %
  242.  
  243. /putoffset {        % <str> <index> <offset> <offsize> putoffset -
  244.     % The saved index points just beyond the end of the number,
  245.     % and we wrote a zero as the placeholder.
  246.     % Consequently, we don't need the offset size.
  247.   pop {
  248.     dup 0 eq { exit } if
  249.     exch 1 sub exch 3 copy 255 and put -8 bitshift
  250.   } loop pop pop pop
  251. } def
  252.  
  253. /writecff {        % <file> [<font> ...] writecff -
  254.   30 dict begin
  255.     % The dictionary for each font contains:
  256.     %    font - the original Type 2 font
  257.     %    subrs - the Local Subrs Index
  258.     %    chars - the CharStrings Index
  259.     %    private - the Private Dict
  260.     %    top - the Top Dict
  261.     %    charspos - the offset of the CharStrings Dict relative to
  262.     %      the start of all CharStrings
  263.     %    privatepos - the offset of the Private Dict relative to
  264.     %      the start of all Private Dicts
  265.     %    subrsoffset - the offset of the Local Subrs offset
  266.     %      reference in the Private Dict
  267.     %    charstringsoffset - the offset of the CharStrings offset
  268.     %      reference in the Top dict
  269.     %    privateoffset - the offset of the Private Dict offset
  270.     %      reference in the Top dict
  271.   [ exch { 12 dict begin /font exch cvlit def currentdict end } forall ]
  272.   /fonts exch def
  273.   /cff exch cvlit def
  274.  
  275.   /f cff def
  276.   /fpos 0 def
  277.  
  278.     % We need to pre-construct all the strings so that we know
  279.     % the offsets to fill in.
  280.  
  281.   /names { [ fonts { /font get /FontName get } forall ] Index } collect def
  282.   /sids 20 dict def
  283.   /subrslength 0 def        % only for estimating size
  284.   /charslength 0 def
  285.   /privatelength 0 def
  286.   fonts {
  287.     begin
  288.     font /Private get /Subrs .knownget {
  289.       { Index } collect
  290.     } {
  291.       <00 00>
  292.     } ifelse /subrs exch def
  293.     /subrslength subrslength subrs length add def
  294.     %****** FOLLOWING IS WRONG, WRONG, WRONG ******%
  295.     font /CharStrings get [ exch { exch pop } forall ] { Index } collect
  296.     /chars exch def
  297.     /charspos charslength def
  298.     /charslength charslength chars length add def
  299.     /subrsoffset null def
  300.     font /Private get { privatekeyops Dict } collect /private exch def
  301.     subrsoffset null ne {
  302.       private subrsoffset private length 2 putoffset
  303.     } if
  304.     /privatepos privatelength def
  305.     /privatelength privatelength private length add subrs length add def
  306.   } forall
  307.     % Estimate the size of a 0-based offset for the Top Dicts.
  308.   /offsetsize subrslength charslength add privatelength add
  309.     60000 ge { 3 } { 2 } ifelse def
  310.   fonts {
  311.     begin
  312.     /charstringsoffset null def
  313.     /privateoffset null def
  314.     /top { font topkeyops Dict } collect def
  315.     end
  316.   } forall
  317.   /strings { sids StandardSIDs length idIndex } collect def
  318.  
  319.     % Now we can write the real file.
  320.     % Header
  321.   DEBUG { (header ) print fpos == } if
  322.   <01 00 04 02> nextstring
  323.     % Name Index
  324.   DEBUG { (names ) print fpos == } if
  325.   names nextstring
  326.     % Top Dicts
  327.   DEBUG { (tops ) print fpos == } if
  328.   /charsbase fpos fonts { /top get length add } forall strings length add def
  329.   /privatebase charsbase charslength add def
  330.   fonts {
  331.     begin
  332.     top charstringsoffset charspos charsbase add offsetsize putoffset
  333.     top privateoffset privatepos privatebase add offsetsize putoffset
  334.     top nextstring
  335.     end
  336.   } forall
  337.     % String Index
  338.   DEBUG { (strings ) print fpos == } if
  339.   strings nextstring
  340.     % Charstrings Indexes
  341.   DEBUG { (charstrings) print } if
  342.   /charsbase fpos def
  343.   fonts {
  344.     DEBUG { ( ) print fpos =only } if /chars get nextstring
  345.   } forall
  346.   DEBUG { () = } if
  347.     % Private Dicts & Local Subr Indexes
  348.   DEBUG { (privates/subrs) print } if
  349.   fonts {
  350.     DEBUG { ( ) print fpos =only } if dup /private get nextstring
  351.     DEBUG { ( ) print fpos =only } if /subrs get nextstring
  352.   } forall
  353.   DEBUG { () = } if
  354.  
  355.   DEBUG { (end ) print fpos = flush } if
  356.   end
  357. } def
  358.  
  359. % ---------------- Wrap up ---------------- %
  360.  
  361. currentdict readonly end
  362. /writecffdict exch def
  363.  
  364. /writecff {
  365.   writecffdict begin writecff end
  366. } def
  367.